package com.qf.talk.controller;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.qf.base.controller.BaseController;
import com.qf.base.push.MessageDTO;
import com.qf.base.result.R;
import com.qf.base.utils.AsyncBatchCallUtil;
import com.qf.base.utils.SnowFlakeUtil;
import com.qf.talk.client.PushClient;
import com.qf.talk.client.UserClient;
import com.qf.talk.dto.AddFriendDTO;
import com.qf.talk.dto.AskForDTO;
import com.qf.talk.dto.DelFriendDTO;
import com.qf.talk.dto.MarkNameDTO;
import com.qf.talk.model.FriendRequestAdd;
import com.qf.talk.model.UserCache;
import com.qf.talk.service.FriendService;
import com.qf.talk.vo.FriendVO;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/friend")
public class FriendController extends BaseController {

    @Resource
    FriendService friendService;
    @Resource
    PushClient pushClient;
    @Resource
    SnowFlakeUtil snowFlakeUtil;
    @Resource
    private UserClient userClient;

    //添加好友
    @PostMapping("/base")
    public R addFriend(@RequestBody AddFriendDTO addFriendDTO){
        //获取用户所传递的token 然后根据token反编译成用户，然后获取id
        Long userId=userId();
        Long wantUserId=addFriendDTO.getWantUserId();
        String message=addFriendDTO.getMessage();
        int result = friendService.addFriend(userId, wantUserId, message);
        if (result==-1){
            //添加失败
            return R.error(501,"添加失败");
        }else if (result==1){

            //添加成功
            //调用推送服务
            long requestId= snowFlakeUtil.nextId();
            MessageDTO messageDTO=new MessageDTO();
            messageDTO.setRequestId(requestId);
            messageDTO.setType(1);
            messageDTO.setUid(wantUserId);
            JSONObject jsonObject=new JSONObject();
            jsonObject.put("user", user());
            //为了区分聊天消息里到底是有人请求添加还是认为添加，还是有人和用户说话
            jsonObject.put("flag", 1);
            jsonObject.put("content", user().getNickname()+"已经添加你位好友");
            messageDTO.setMessage(jsonObject.toJSONString());
            //发送消息
            pushClient.send(messageDTO);
            //通知wantUserId这个用户，userId这个用户添加你为好友
            return R.ok(200,"添加成功");
        }else if (result==2){
            //等待对方验证
            //推送给被添加的目标用户
            //xxx已经申请添加你为好友
            //调用推送服务
            long requestId= snowFlakeUtil.nextId();
            MessageDTO messageDTO=new MessageDTO();
            messageDTO.setRequestId(requestId);
            messageDTO.setType(1);
            messageDTO.setUid(wantUserId);
            JSONObject jsonObject=new JSONObject();
            jsonObject.put("user", user());
            //为了区分聊天消息里到底是有人请求添加还是认为添加，还是有人和用户说话
            jsonObject.put("flag", 2);
            jsonObject.put("content", user().getNickname()+"请求添加你位好友");
            messageDTO.setMessage(jsonObject.toJSONString());
            pushClient.send(messageDTO);

            return R.ok(201,"等待对方验证");
        }


        return R.error("未知错误，添加失败");





    }
    //确认好友
    @PostMapping("/askfor")
    public R askFor(@RequestBody AskForDTO askForDTO){

        Long selfId = userId();
        Long requestId=askForDTO.getRequestId();
        Integer state=askForDTO.getState();
        int result = friendService.askRequest(requestId, state,selfId);
        if (result==1){
            return  R.success("该请求已经同意");
        }else if (result==0){
            return R.success("该请求已经拒绝");
        }else if (result==-1){
            return R.error(403,"您无权处理此请求");
        }
        return R.error(500,"未知错误");
    }


    /**
     * 展示用户所有的好友
     * 粗粒度因此我们需要请求用户中心
     */
    @GetMapping("/friendc")
    public R findFriends(){
        //根据tonken获取到该用户的id
        Long userId = userId();
        //根据id获取他所有的好友
        //不仅仅是好友的id，显示给前端的时候，势必要有备注名称，好友分组的情况等
        //好友分组应该由顺序的问题
        //返回组的名称，组的id
        List<FriendVO> friends = friendService.findFriends(userId);
        //请求用户中心，根据好友id的集合，查询出所有好友的详细信息
        List<Long> userIds=new ArrayList<>();

        for (int i=0;i<friends.size();i++){
            //收集所有的好友id
            userIds.add(friends.get(i).getFriendId());
        }
        Map map=new HashMap();
        map.put("userIds", userIds);

        AsyncBatchCallUtil.execute(new Runnable() {
            @Override
            public void run() {
                String userServiceJson = userClient.batch(map);
                //去除用户的数组
                JSONArray userInfos = JSONObject.parseObject(userServiceJson).getJSONArray("result");
                //最新的userInfors数据已经回来了
                List<UserCache> users=JSONArray.parseArray(userInfos.toJSONString(),UserCache.class);
                //更新本地数据库
                friendService.updateUserCache(users);
            }
        });
        List<UserCache> userCaches = friendService.findUserCacheByIds(userIds);


        //打包json返回
        JSONObject jsonObject=new JSONObject();
        jsonObject.put("userInfos", userCaches);
        jsonObject.put("friendInfos", friends);


        return R.success(jsonObject);
    }
    //查询请求添加
    @GetMapping("/requsetAdd")
    public R findRequestAdd(){
        Long userId=userId();
        //查询所有请求
        List<FriendRequestAdd> requestAdds = friendService.findRequestAdd(userId);
        //requestAdd里没有用户详细信息
        //需要请求用户中心
        List<Long> userIds=new ArrayList<>();

        for (int i=0;i<requestAdds.size();i++){
            //收集所有的好友id
            userIds.add(requestAdds.get(i).getUserId());
        }
        Map map=new HashMap();
        map.put("userIds", userIds);
        //更新用户信息
        AsyncBatchCallUtil.execute(new Runnable() {
            @Override
            public void run() {
                String userServiceJson = userClient.batch(map);
                //取出用户的数组
                JSONArray userInfos = JSONObject.parseObject(userServiceJson).getJSONArray("result");
                //最新的userInfos数据已经回来了
                List<UserCache> users = JSONArray.parseArray(userInfos.toJSONString(), UserCache.class);
                //更新本地数据库
                friendService.updateUserCache(users);
            }
        });
        List<UserCache> userCaches=friendService.findUserCacheByIds(userIds);
        //打包json返回
        JSONObject jsonObject=new JSONObject();
        jsonObject.put("userInfos", userCaches);
        jsonObject.put("friendInfos", requestAdds);
        return R.success(jsonObject);
    }

    /**
     * 删除好友，token中拥有用户id，报文中拥有用户对应的好友id
     * @param delFriendDTO
     * @return
     */
    @DeleteMapping("/frienddelete")
    public R deleteFriend(@RequestBody DelFriendDTO delFriendDTO){

        Long userId=userId();
        Long friendId = delFriendDTO.getFriendId();
        int result = friendService.deleteFriend(userId, friendId);
        if (result>0){
            return R.ok("删除成功");
        }else {
            return R.error("删除失败");
        }
    }

    /**
     * 修改好友备注
     * @return
     */
    @PutMapping("/update")
    public R editFriendMarkName(@RequestBody MarkNameDTO markNameDTO){
        Long userId = userId();
        String markName=markNameDTO.getMarkName();
        Long friendId=markNameDTO.getFriendId();
        int result = friendService.editFriendMarkName(userId, friendId, markName);
        if (result==0){
            return R.error("设置失败");
        }else {
            return R.ok("设置成功    ");
        }
    }

}
